package continuity;

/**
 * Az irányokat tartja nyilván.
 * @author FornetTeam
 */
public enum Direction {
    Left {@Override public int toInt() {return 0;}},
    Down {@Override public int toInt() {return 1;}},
    Right {@Override public int toInt() {return 2;}},
    Up {@Override public int toInt() {return 3;}};
    
    /**
     * Az ellentétes irányt adja vissza.
     * @return 
     */
    public Direction getOpposite() {
        Direction ret;
        switch(this) {
            case Left:
                ret=Right;
                break;
            case Down:
                ret=Up;
                break;
            case Right:
                ret=Left;
                break;
            case Up:
                ret=Down;
                break;
            default:
                ret=null;
        }
        return ret;
    }
    
    /**
     * Az irányt reprezentáló egész számot adja vissza.
     * Left: 0
     * Down: 1
     * Right: 2
     * Up: 3
     * Ezekkel a számokkal lehet a listákat indexelni.
     * @return Az irányt reprezentáló egész szám.
     */
    public abstract int toInt();
    
    /**
     * Directionné konvertálja a paraméterként kapott intet.
     * Left: 0
     * Down: 1
     * Right: 2
     * Up: 3
     * @param dir A konvertálandó int.
     * @return A integerhez tartozó irány.
     * @throws IllegalArgumentException Ha a bemenet kisebb mint 0 vagy nagyobb mint 3.
     */
    public static Direction intToDirection(int dir){
        /**
         * A paraméter ellenőrzése.
         */
        if (dir < 0 || dir > 3)
            throw new IllegalArgumentException("The value "+dir+" can not be converted to Direction.");
        
        /**
         * Konvertálás
         */
        Direction ret = null;
        switch (dir) {
            case 0:
                ret = Left;
                break;
            case 1:
                ret = Down;
                break;
            case 2:
                ret = Right;
                break;
            case 3:
                ret = Up;
                break;
        }
        
        return ret;
    }
    
    /**
     * Directionné konvertálja a paraméterként kapott Stringet.
     * @param dir Az irány String formátumban.
     * @return A paraméterként kapott String Direction-né konvertálva.
     * @throws IllegalArgumentException Ha a paraméterként kapott String nem érvényes irány.
     */
    public static Direction parseDirection(String dir){
        Direction ret = null;
        
        /**
         * Konvertálás
         */
        String ldir = dir.toLowerCase();
        if (ldir.equals("left")){
            ret = Left;
        }else if (ldir.equals("down")){
            ret = Down;
        } else if (ldir.equals("right")){
            ret = Right;
        } else if (ldir.equals("up")){
            ret = Up;
        } else {
            throw new IllegalArgumentException("The String \""+dir+"\" can not be convert to Direction");
        }
        
        return ret;
    }
}
